/**
 * 自定义节点类型控制器
 * 处理自定义节点类型相关的API请求
 */
const CustomNodeType = require('../models/customNodeType')

/**
 * 获取所有自定义节点类型
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getAllCustomNodeTypes(req, res) {
  try {
    const customNodeTypes = CustomNodeType.getCustomNodeTypes()
    res.json(customNodeTypes)
  } catch (error) {
    console.error('获取自定义节点类型列表失败:', error)
    res.status(500).json({ error: '获取自定义节点类型列表失败' })
  }
}

/**
 * 获取单个自定义节点类型
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getCustomNodeTypeById(req, res) {
  try {
    const { id } = req.params
    const nodeType = CustomNodeType.getCustomNodeTypeById(id)
    
    if (!nodeType) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    res.json(nodeType)
  } catch (error) {
    console.error('获取自定义节点类型详情失败:', error)
    res.status(500).json({ error: '获取自定义节点类型详情失败' })
  }
}

/**
 * 创建自定义节点类型
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function createCustomNodeType(req, res) {
  try {
    const nodeType = req.body
    
    if (!nodeType.name) {
      return res.status(400).json({ error: '缺少必要字段: name' })
    }
    
    const newNodeType = CustomNodeType.createCustomNodeType(nodeType)
    res.status(201).json(newNodeType)
  } catch (error) {
    console.error('创建自定义节点类型失败:', error)
    res.status(500).json({ error: '创建自定义节点类型失败' })
  }
}

/**
 * 更新自定义节点类型
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function updateCustomNodeType(req, res) {
  try {
    const { id } = req.params
    const nodeType = req.body
    
    if (!nodeType.name) {
      return res.status(400).json({ error: '缺少必要字段: name' })
    }
    
    const updatedNodeType = CustomNodeType.updateCustomNodeType(id, nodeType)
    
    if (!updatedNodeType) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    res.json(updatedNodeType)
  } catch (error) {
    console.error('更新自定义节点类型失败:', error)
    res.status(500).json({ error: '更新自定义节点类型失败' })
  }
}

/**
 * 删除自定义节点类型
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function deleteCustomNodeType(req, res) {
  try {
    const { id } = req.params
    const success = CustomNodeType.deleteCustomNodeType(id)
    
    if (!success) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    res.status(204).end()
  } catch (error) {
    console.error('删除自定义节点类型失败:', error)
    res.status(500).json({ error: '删除自定义节点类型失败' })
  }
}

/**
 * 获取自定义节点类型的所有版本
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getVersionsByNodeTypeId(req, res) {
  try {
    const { id } = req.params
    
    // 先检查节点类型是否存在
    const nodeType = CustomNodeType.getCustomNodeTypeById(id)
    if (!nodeType) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    const versions = CustomNodeType.getVersionsByNodeTypeId(id)
    res.json(versions)
  } catch (error) {
    console.error('获取自定义节点类型版本列表失败:', error)
    res.status(500).json({ error: '获取自定义节点类型版本列表失败' })
  }
}

/**
 * 创建自定义节点类型的新版本
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function createVersion(req, res) {
  try {
    const { id } = req.params
    const version = req.body
    
    if (!version.version || !version.description) {
      return res.status(400).json({ error: '缺少必要字段: version, description' })
    }
    
    // 先检查节点类型是否存在
    const nodeType = CustomNodeType.getCustomNodeTypeById(id)
    if (!nodeType) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    const newVersion = CustomNodeType.createVersion(id, version)
    
    if (!newVersion) {
      return res.status(500).json({ error: '创建版本失败' })
    }
    
    res.status(201).json(newVersion)
  } catch (error) {
    console.error('创建自定义节点类型版本失败:', error)
    res.status(500).json({ error: '创建自定义节点类型版本失败' })
  }
}

/**
 * 发布自定义节点类型的版本
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function publishVersion(req, res) {
  try {
    const { id, versionId } = req.params
    
    // 先检查节点类型是否存在
    const nodeType = CustomNodeType.getCustomNodeTypeById(id)
    if (!nodeType) {
      return res.status(404).json({ error: '未找到指定的自定义节点类型' })
    }
    
    // 再检查版本是否存在
    const version = CustomNodeType.getVersionById(versionId)
    if (!version || version.nodeTypeId !== id) {
      return res.status(404).json({ error: '未找到指定的版本或版本不属于此节点类型' })
    }
    
    const publishedVersion = CustomNodeType.publishVersion(id, versionId)
    
    if (!publishedVersion) {
      return res.status(500).json({ error: '发布版本失败' })
    }
    
    res.json(publishedVersion)
  } catch (error) {
    console.error('发布自定义节点类型版本失败:', error)
    res.status(500).json({ error: '发布自定义节点类型版本失败' })
  }
}

/**
 * 获取所有已发布的自定义节点类型版本
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getPublishedVersions(req, res) {
  try {
    const publishedVersions = CustomNodeType.getPublishedVersions()
    res.json(publishedVersions)
  } catch (error) {
    console.error('获取已发布自定义节点类型版本列表失败:', error)
    res.status(500).json({ error: '获取已发布自定义节点类型版本列表失败' })
  }
}

/**
 * 获取自定义节点类型被哪些事件使用
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getCustomNodeTypeUsage(req, res) {
  try {
    const { id } = req.params
    const { page = 1, pageSize = 10 } = req.query
    
    const pageNum = parseInt(page)
    const size = parseInt(pageSize)
    
    const result = CustomNodeType.findEventsUsingCustomNodeType(id, pageNum, size)
    res.json(result)
  } catch (error) {
    console.error('获取自定义节点类型使用情况失败:', error)
    res.status(500).json({ error: '获取自定义节点类型使用情况失败' })
  }
}

/**
 * 获取引用特定版本的所有事件
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
function getVersionEvents(req, res) {
  try {
    const { versionId } = req.params
    const { page = 1, pageSize = 10 } = req.query
    
    const pageNum = parseInt(page)
    const size = parseInt(pageSize)
    
    const result = CustomNodeType.findEventsByVersionId(versionId, pageNum, size)
    res.json(result)
  } catch (error) {
    console.error('获取引用版本的事件列表失败:', error)
    res.status(500).json({ error: '获取引用版本的事件列表失败' })
  }
}

module.exports = {
  getAllCustomNodeTypes,
  getCustomNodeTypeById,
  createCustomNodeType,
  updateCustomNodeType,
  deleteCustomNodeType,
  getVersionsByNodeTypeId,
  createVersion,
  publishVersion,
  getPublishedVersions,
  getCustomNodeTypeUsage,
  getVersionEvents
} 